package com.forum.core.dao.jdbc;

import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.simple.ParameterizedBeanPropertyRowMapper;
import org.springframework.util.Assert;

/**
 * @Company <Jinher Technology Development Company LTD.>
 * @Project <Jinher Collaboration Suite>
 * @version <1.0>
 * @Author  <yangzq>
 * @Date    <May 18, 2009>
 * @description 
 */
@SuppressWarnings("unchecked")
public class SimpleJdbcTemplate {
	
	//protected final Log logger = LogFactory.getLog(getClass());
	@Autowired
	protected  DataSource dataSource;
	
	protected  org.springframework.jdbc.core.simple.SimpleJdbcTemplate jdbcTemplate;
	
	public SimpleJdbcTemplate(){
		
	}
	
	public SimpleJdbcTemplate(DataSource dataSource){
		
		jdbcTemplate=new org.springframework.jdbc.core.simple.SimpleJdbcTemplate(dataSource);
	}
	
	/**
	 * 根据sql语句，返回对象集合

	 * @param sql语句(参数用冒号加参数名，例如select * from tb where id=:id)
	 * @param clazz类型
	 * @param parameters参数集合(key为参数名，value为参数值)
	 * @return bean对象集合
	 */
	public  List find(final String sql,Class clazz,Map parameters){
		try{
			Assert.hasText(sql,"sql语句不正确!");
			Assert.notNull(clazz,"集合中对象类型不能为空!");
			if(parameters!=null){
				
				return getJdbcTemplate().query(sql, resultBeanMapper(clazz),parameters);
				
			}else{
				return getJdbcTemplate().query(sql, resultBeanMapper(clazz));
			}
		}catch (Exception e) {
			return null;
		}
	}
	/**
	 * 根据sql语句，返回对象集合

	 * @param sql语句(参数用冒号加参数名，例如select * from tb where id=:id)
	 * @param clazz类型
	 * @param 可变参数
	 * @return bean对象集合
	 */
	public  List find(final String sql,Class clazz,Object...values){
		try{
			Assert.hasText(sql,"sql语句不正确!");
			Assert.notNull(clazz,"集合中对象类型不能为空!");
			return getJdbcTemplate().query(sql, resultBeanMapper(clazz),values);
		}catch (Exception e) {
			return null;
		}
	}
	
	/**
	 * 根据sql语句，返回对象

	 * @param sql语句(参数用冒号加参数名，例如select * from tb where id=:id)
	 * @param clazz类型
	 * @param parameters参数集合(key为参数名，value为参数值)
	 * @return bean对象
	 */
	public  Object findForObject(final String sql,Class clazz,Map parameters){
		try{
			Assert.hasText(sql,"sql语句不正确!");
			Assert.notNull(clazz,"集合中对象类型不能为空!");
			if(parameters!=null){
				return getJdbcTemplate().queryForObject(sql, resultBeanMapper(clazz), parameters);
			}else{
				return getJdbcTemplate().queryForLong(sql, resultBeanMapper(clazz));
			}
		}catch (Exception e) {
			return null;
		}
	}
	
	/**
	 * 根据sql语句，返回数值型返回结果
	 * @param sql语句(参数用冒号加参数名，例如select count(*) from tb where id=:id)
	 * @param parameters参数集合(key为参数名，value为参数值)
	 * @return bean对象
	 */
	public  long findForLong(final String sql,Map parameters){
		try{
			Assert.hasText(sql,"sql语句不正确!");
			if(parameters!=null){
				return getJdbcTemplate().queryForLong(sql, parameters);
			}else{
				return getJdbcTemplate().queryForLong(sql);
			}
		}catch (Exception e) {
			return 0;
		}
	}
	
	
	/**
	 * 根据sql语句，返回数值型返回结果
	 * @param sql语句(参数用冒号加参数名，例如select count(*) from tb where id=:id)
	 * @param parameters参数集合(key为参数名，value为参数值)
	 * @return bean对象
	 */
	public int findForInt(final String sql,Map parameters){
		try{
			Assert.hasText(sql,"sql语句不正确!");
			if(parameters!=null){
				return getJdbcTemplate().queryForInt(sql, parameters);
			}else{
				return getJdbcTemplate().queryForInt(sql, parameters);
			}
		}catch (Exception e) {
			return 0;
		}
	}
	
	/**
	 * 根据sql语句，返回Map对象,对于某些项目来说，没有准备Bean对象，则可以使用Map代替Key为字段名,value为值

	 * @param sql语句(参数用冒号加参数名，例如select count(*) from tb where id=:id)
	 * @param parameters参数集合(key为参数名，value为参数值)
	 * @return bean对象
	 */
	public  Map findForMap(final String sql,Map parameters){
		try{
			Assert.hasText(sql,"sql语句不正确!");
			if(parameters!=null){
				return getJdbcTemplate().queryForMap(sql, parameters);
			}else{
				return getJdbcTemplate().queryForMap(sql);
			}
		}catch (Exception e) {
			return null;
		}
	}
	
	/**
	 * 根据sql语句，返回Map对象集合
	 * @see findForMap
	 * @param sql语句(参数用冒号加参数名，例如select count(*) from tb where id=:id)
	 * @param parameters参数集合(key为参数名，value为参数值)
	 * @return bean对象
	 */
	public  List<Map<String,Object>> findForListMap(final String sql,Map parameters){
		try{
			Assert.hasText(sql,"sql语句不正确!");
			if(parameters!=null){
				return getJdbcTemplate().queryForList(sql, parameters);
			}else{
				return getJdbcTemplate().queryForList(sql);
			}
		}catch (Exception e) {
			return null;
		}
	}
	
	/**
	 * 执行insert，update，delete等操作<br>
	 * 例如insert into users (name,login_name,password) values(:name,:loginName,:password)<br>
	 * 参数用冒号,参数为bean的属性名
	 * @param sql
	 * @param bean
	 */
	public  int executeForObject(final String sql,Object bean){
		Assert.hasText(sql,"sql语句不正确!");
		if(bean!=null){
			return getJdbcTemplate().update(sql, paramBeanMapper(bean));
		}else{
			return getJdbcTemplate().update(sql);
		}
	}

	/**
	 * 执行insert，update，delete等操作<br>
	 * 例如insert into users (name,login_name,password) values(:name,:login_name,:password)<br>
	 * 参数用冒号,参数为Map的key名

	 * @param sql
	 * @param parameters
	 */
	public  int executeForMap(final String sql,Map parameters){
		Assert.hasText(sql,"sql语句不正确!");
		if(parameters!=null){
			return getJdbcTemplate().update(sql, parameters);
		}else{
			return getJdbcTemplate().update(sql);
		}
	}
	
	/*public long executeForObjectReturnPk(final String sql,Object bean){
		Assert.hasText(sql,"sql语句不正确!");
		if(bean!=null){
			return jdbcTemplate.update(sql, paramBeanMapper(bean));
		}else{
			return jdbcTemplate.update(sql);
		}
	}*/
	
	protected  ParameterizedBeanPropertyRowMapper resultBeanMapper(Class clazz) {
		return ParameterizedBeanPropertyRowMapper.newInstance(clazz);
	}
	
	protected  BeanPropertySqlParameterSource paramBeanMapper(Object object) {
		return new BeanPropertySqlParameterSource(object);
	}

	public DataSource getDataSource() {
		return dataSource;
	}

	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
	
	public org.springframework.jdbc.core.simple.SimpleJdbcTemplate getJdbcTemplate(){
		if(jdbcTemplate==null)
			jdbcTemplate=new org.springframework.jdbc.core.simple.SimpleJdbcTemplate(dataSource);
		return jdbcTemplate;
	}
}
